// import Agreement from '@/static/js/Agreement.js';
const ble = uni.requireNativePlugin('sand-plugin-bluetooth');

class QFB_Sanhe_001  {
	constructor() {
		// super();
		// 实例私有属性（每个设备独立）
		this.deviceId = null; // 当前实例绑定的设备ID
		this.callbacks = {
			deviceList: null,
			data: null,
			status: null,
			linkSuccess: null
		};
		this.listenerIds = {
			adapterState: null,
			deviceFound: null,
			connectionState: null,
			dataChange: null
		}; // 存储事件监听ID，用于销毁
		this.initListener(); // 初始化监听（每个实例独立）
	}

	/**
	 * 初始化蓝牙事件监听（每个实例独立过滤设备ID）
	 */
	initListener() {
		const that = this;

		// 1. 蓝牙适配器状态变化监听
		this.listenerIds.adapterState = ble.onBluetoothAdapterStateChange({}, (res) => {
			console.log(`设备${that.deviceId || '未绑定'}适配器状态变化:`, res);
		});

		// 2. 发现设备监听（仅在扫描时生效）
		this.listenerIds.deviceFound = ble.onBluetoothDeviceFound({}, (res) => {
			if (res.status !== '2500') return;
			const devices = JSON.parse(res.devices || '[]');
			if (typeof that.callbacks.deviceList === 'function') {
				that.callbacks.deviceList(devices);
			}
		});

		// 3. 连接状态变化监听（仅处理当前设备）
		this.listenerIds.connectionState = ble.onBLEConnectionStateChange({}, (res) => {
			const {
				deviceId,
				connected
			} = res;
			// 过滤非当前实例绑定的设备
			if (deviceId !== that.deviceId) return;

			// 连接成功时订阅特征值
			if (connected) {
				that.notify(deviceId);
			}
			// 触发状态回调
			if (typeof that.callbacks.status === 'function') {
				that.callbacks.status(deviceId, connected);
			}
		});

		// 4. 特征值数据变化监听（仅处理当前设备）
		this.listenerIds.dataChange = ble.onBLECharacteristicValueChange({}, (res) => {
			if (res.status !== '2500') return;
			// 过滤非当前设备的数据
			if (res.deviceId !== that.deviceId) return;

			that.handleReceivedData(res);
		});

		// 确保蓝牙适配器已打开
		ble.openBluetoothAdapter({}, (res) => {
			if (res.status !== '2500') {
				console.error(`设备${that.deviceId || '未绑定'}适配器打开失败:`, res.message);
			}
		});
	}

	/**
	 * 连接设备
	 * @param {string} connectId - 设备ID（为空时扫描设备）
	 * @param {function} callBackDeviceList - 扫描到设备的回调
	 * @param {function} callBackLinkSuccess - 连接成功的回调
	 */
	Link(connectId, callBackDeviceList, callBackLinkSuccess) {
		this.callbacks.deviceList = callBackDeviceList;
		this.callbacks.linkSuccess = callBackLinkSuccess;

		if (!connectId) {
			// 开始扫描设备
			ble.startBluetoothDevicesDiscovery({}, (res) => {
				if (res.status !== '2500') {
					console.warn('扫描设备失败:', res.message);
				}
			});
		} else {
			// 绑定设备ID并连接
			this.deviceId = connectId;
			// 停止扫描后连接
			ble.stopBluetoothDevicesDiscovery({}, () => {
				ble.createBLEConnection({
					deviceId: connectId
				}, (res) => {
					if (typeof callBackLinkSuccess === 'function') {
						callBackLinkSuccess(res);
					}
				});
			});
		}
	}

	/**
	 * 停止扫描设备
	 */
	StopFind() {
		ble.stopBluetoothDevicesDiscovery({}, (res) => {
			if (res.status !== '2500') {
				console.warn('停止扫描失败:', res.message);
			}
		});
	}

	/**
	 * 获取已连接设备
	 * @param {function} callBackGetLink - 回调函数
	 */
	getConnected(callBackGetLink) {
		ble.getConnectedBluetoothDevices({}, (res) => {
			if (typeof callBackGetLink === 'function') {
				callBackGetLink(res);
			}
		});
	}

	/**
	 * 绑定状态变化回调
	 * @param {function} callBackGetStatus - (deviceId, connected) => {}
	 */
	GetStatus(callBackGetStatus) {
		this.callbacks.status = callBackGetStatus;
	}

	/**
	 * 断开设备连接
	 * @param {string} deviceId - 设备ID
	 */
	Disconnect(deviceId) {
		if (!deviceId || deviceId !== this.deviceId) return;

		// 移除自动重连并断开连接
		ble.removeAutoReconnect({
			deviceId
		}, (res) => {
			ble.closeBLEConnection({
				deviceId
			}, (res2) => {
				if (res2.status !== '2500') {
					console.warn(`设备${deviceId}断开失败:`, res2.message);
				}
			});
		});

		// 清理当前实例的事件监听（防止内存泄漏）
		this.cleanupListeners();
		this.deviceId = null; // 清空设备ID
	}

	/**
	 * 绑定数据接收回调
	 * @param {function} callBackData - (data) => {} 数据格式: { Nums, Model }
	 */
	CallBackGetData(callBackData) {
		this.callbacks.data = callBackData;
	}

	/**
	 * 写入数据（预留实现）
	 */
	WriteData() {
		// 如需实现写入功能，需传入deviceId、serviceId、characteristicId和数据
		console.warn('WriteData方法未实现');
	}

	/**
	 * 订阅设备特征值通知
	 * @param {string} deviceId - 设备ID
	 */
	notify(deviceId) {
		if (!deviceId) return;

		// 延迟获取服务，避免连接未稳定
		setTimeout(() => {
			ble.getBLEDeviceServices({
				deviceId
			}, (res) => {
				if (res.status !== '2500') {
					console.error(`获取设备${deviceId}服务失败:`, res.message);
					return;
				}

				const services = JSON.parse(res.services || '[]');
				this.traverseServices(deviceId, services, 0);
			});
		}, 500);
	}

	/**
	 * 递归遍历服务和特征值
	 * @param {string} deviceId - 设备ID
	 * @param {array} services - 服务列表
	 * @param {number} index - 当前遍历索引
	 */
	traverseServices(deviceId, services, index) {
		if (index >= services.length) return;

		const service = services[index];
		ble.getBLEDeviceCharacteristics({
			deviceId,
			serviceId: service.uuid
		}, (res) => {
			if (res.status !== '2500') {
				console.warn(`获取服务${service.uuid}特征值失败:`, res.message);
				this.traverseServices(deviceId, services, index + 1);
				return;
			}

			const characteristics = JSON.parse(res.characteristics || '[]');
			this.handleCharacteristics(deviceId, service.uuid, characteristics);
			// 继续遍历下一个服务
			this.traverseServices(deviceId, services, index + 1);
		});
	}

	/**
	 * 处理特征值（订阅通知、读取、写入）
	 * @param {string} deviceId - 设备ID
	 * @param {string} serviceId - 服务ID
	 * @param {array} characteristics - 特征值列表
	 */
	handleCharacteristics(deviceId, serviceId, characteristics) {
		characteristics.forEach(characteristic => {
			// 订阅通知
			if (characteristic.properties.notify) {
				ble.notifyBLECharacteristicValueChange({
					deviceId,
					serviceId,
					characteristicId: characteristic.uuid
				}, (res) => {
					if (res.status !== '2500') {
						console.warn(`订阅特征值${characteristic.uuid}失败:`, res.message);
					}
				});
			}

			// 读取特征值
			if (characteristic.properties.read) {
				ble.readBLECharacteristicValue({
					deviceId,
					serviceId,
					characteristicId: characteristic.uuid
				}, (res) => {
					if (res.status !== '2500') {
						console.warn(`读取特征值${characteristic.uuid}失败:`, res.message);
					}
				});
			}

			// 写入初始值（如需要）
			if (characteristic.properties.write) {
				ble.writeBLECharacteristicValue({
					deviceId,
					serviceId,
					characteristicId: characteristic.uuid,
					value: "01" // 十六进制初始数据
				}, (res) => {
					if (res.status !== '2500') {
						console.warn(`写入特征值${characteristic.uuid}失败:`, res.message);
					}
				});
			}
		});
	}

	/**
	 * 处理接收到的原始数据
	 * @param {object} res - 原始数据响应
	 */
	handleReceivedData(res) {
		try {
			const originValue = this.hex2Bytes(res.value);
			if (!originValue || originValue.length < 7) {
				throw new Error('数据长度不足，格式错误');
			}

			// 解析测量值（原始值为实际值的100倍）
			const allNums = (originValue[4] << 16) + (originValue[5] << 8) + originValue[6];
			const nums = allNums / 100;

			if (isNaN(nums)) {
				throw new Error('数据解析失败，非有效数字');
			}
			
			// 更改为直接发送数据给 basic 监听器
			uni.$emit("send:bluetooth-data", {
				data: Nums,
				Model: res
			})

			// 触发数据回调
			if (typeof this.callbacks.data === 'function') {
				this.callbacks.data({
					Nums: nums,
					Model: res
				});
				
				
			}
		} catch (error) {
			console.error(`设备${this.deviceId}数据处理错误:`, error.message);
		}
	}

	/**
	 * 十六进制字符串转字节数组
	 * @param {string} hexStr - 十六进制字符串
	 * @returns {array|null} 字节数组
	 */
	hex2Bytes(hexStr) {
		if (!hexStr || hexStr.length % 2 !== 0) {
			return null;
		}

		const hexA = [];
		for (let i = 0; i < hexStr.length; i += 2) {
			const s = hexStr.substr(i, 2);
			hexA.push(parseInt(s, 16));
		}
		return hexA;
	}

	/**
	 * 清理当前实例的所有事件监听
	 */
	cleanupListeners() {
		Object.values(this.listenerIds).forEach(listenerId => {
			if (listenerId) {
				ble.off(listenerId); // 移除监听（假设插件支持off方法）
			}
		});
		// 重置监听ID
		this.listenerIds = {
			adapterState: null,
			deviceFound: null,
			connectionState: null,
			dataChange: null
		};
	}

	/**
	 * 实例销毁时清理资源（防止内存泄漏）
	 */
	destroy() {
		if (this.deviceId) {
			this.Disconnect(this.deviceId);
		} else {
			this.cleanupListeners();
		}
	}
}

export default QFB_Sanhe_001;